// 位置获取辅助工具
// 针对不同平台提供统一的位置获取接口

/**
 * 检查当前运行环境
 */
export const getPlatform = () => {
  // #ifdef H5
  return 'h5'
  // #endif
  
  // #ifdef MP-WEIXIN
  return 'mp-weixin'
  // #endif
  
  // #ifdef APP-PLUS
  return 'app'
  // #endif
  
  return 'unknown'
}

/**
 * H5环境下的位置获取
 */
export const getLocationH5 = (options = {}) => {
  return new Promise((resolve, reject) => {
    if (!navigator.geolocation) {
      reject(new Error('浏览器不支持地理位置API'))
      return
    }

    const defaultOptions = {
      enableHighAccuracy: true,
      timeout: 15000,
      maximumAge: 30000
    }

    const finalOptions = { ...defaultOptions, ...options }

    console.log('H5环境获取位置，选项:', finalOptions)

    navigator.geolocation.getCurrentPosition(
      (position) => {
        const { latitude, longitude, accuracy } = position.coords
        console.log('H5定位成功:', { latitude, longitude, accuracy })
        
        resolve({
          latitude,
          longitude,
          accuracy,
          platform: 'h5'
        })
      },
      (error) => {
        console.error('H5定位失败:', error)
        
        let errorMessage = '定位失败'
        switch (error.code) {
          case error.PERMISSION_DENIED:
            errorMessage = '用户拒绝了位置权限请求'
            break
          case error.POSITION_UNAVAILABLE:
            errorMessage = '位置信息不可用'
            break
          case error.TIMEOUT:
            errorMessage = '定位请求超时'
            break
          default:
            errorMessage = '未知定位错误'
            break
        }
        
        reject(new Error(errorMessage))
      },
      finalOptions
    )
  })
}

/**
 * 微信小程序环境下的位置获取
 */
export const getLocationMpWeixin = (options = {}) => {
  return new Promise((resolve, reject) => {
    const defaultOptions = {
      type: 'gcj02',
      altitude: true,
      timeout: 15000,
      isHighAccuracy: true,
      highAccuracyExpireTime: 10000
    }

    const finalOptions = { ...defaultOptions, ...options }

    console.log('微信小程序获取位置，选项:', finalOptions)

    uni.getLocation({
      ...finalOptions,
      success: (res) => {
        console.log('微信小程序定位成功:', res)
        resolve({
          ...res,
          platform: 'mp-weixin'
        })
      },
      fail: (error) => {
        console.error('微信小程序定位失败:', error)
        reject(error)
      }
    })
  })
}

/**
 * 统一的位置获取接口
 */
export const getLocation = async (options = {}) => {
  const platform = getPlatform()
  console.log('当前平台:', platform)

  try {
    switch (platform) {
      case 'h5':
        return await getLocationH5(options)
      case 'mp-weixin':
        return await getLocationMpWeixin(options)
      case 'app':
        // APP环境使用uni.getLocation
        return await getLocationMpWeixin(options)
      default:
        throw new Error('不支持的平台')
    }
  } catch (error) {
    console.error('获取位置失败:', error)
    throw error
  }
}

/**
 * 检查位置权限
 */
export const checkLocationPermission = async () => {
  const platform = getPlatform()
  
  try {
    switch (platform) {
      case 'h5':
        // H5环境检查权限
        if (!navigator.geolocation) {
          return { granted: false, reason: '浏览器不支持地理位置API' }
        }
        
        // 检查权限API（如果支持）
        if (navigator.permissions) {
          const permission = await navigator.permissions.query({ name: 'geolocation' })
          return {
            granted: permission.state === 'granted',
            reason: permission.state === 'denied' ? '位置权限被拒绝' : '权限状态: ' + permission.state
          }
        }
        
        return { granted: true, reason: '无法检查权限状态，但支持地理位置API' }
        
      case 'mp-weixin':
        // 微信小程序检查权限
        return new Promise((resolve) => {
          uni.getSetting({
            success: (res) => {
              const granted = res.authSetting['scope.userLocation'] === true
              resolve({
                granted,
                reason: granted ? '已授权' : '未授权或被拒绝'
              })
            },
            fail: () => {
              resolve({ granted: false, reason: '无法获取权限状态' })
            }
          })
        })
        
      default:
        return { granted: false, reason: '不支持的平台' }
    }
  } catch (error) {
    console.error('检查位置权限失败:', error)
    return { granted: false, reason: '检查权限时出错: ' + error.message }
  }
}

/**
 * 请求位置权限
 */
export const requestLocationPermission = async () => {
  const platform = getPlatform()
  
  try {
    switch (platform) {
      case 'h5':
        // H5环境通过尝试获取位置来请求权限
        try {
          await getLocationH5({ timeout: 5000 })
          return { granted: true, reason: '权限已获取' }
        } catch (error) {
          return { granted: false, reason: error.message }
        }
        
      case 'mp-weixin':
        // 微信小程序请求权限
        return new Promise((resolve) => {
          uni.authorize({
            scope: 'scope.userLocation',
            success: () => {
              resolve({ granted: true, reason: '权限已获取' })
            },
            fail: (error) => {
              resolve({ granted: false, reason: '权限请求被拒绝: ' + error.errMsg })
            }
          })
        })
        
      default:
        return { granted: false, reason: '不支持的平台' }
    }
  } catch (error) {
    console.error('请求位置权限失败:', error)
    return { granted: false, reason: '请求权限时出错: ' + error.message }
  }
}

/**
 * 验证坐标是否合理
 */
export const validateCoordinates = (lat, lng) => {
  // 基本范围检查
  if (typeof lat !== 'number' || typeof lng !== 'number') {
    return false
  }
  
  if (lat < -90 || lat > 90 || lng < -180 || lng > 180) {
    return false
  }
  
  // 检查是否为0,0（通常是无效坐标）
  if (lat === 0 && lng === 0) {
    return false
  }
  
  return true
}

/**
 * 计算两点间距离（公里）
 */
export const calculateDistance = (lat1, lng1, lat2, lng2) => {
  const R = 6371 // 地球半径（公里）
  const dLat = (lat2 - lat1) * Math.PI / 180
  const dLng = (lng2 - lng1) * Math.PI / 180
  const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
    Math.cos(lat1 * Math.PI / 180) * Math.cos(lat2 * Math.PI / 180) *
    Math.sin(dLng / 2) * Math.sin(dLng / 2)
  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a))
  return R * c
}

/**
 * 保定市坐标
 */
export const BAODING_COORDINATES = {
  latitude: 38.8721,
  longitude: 115.4925,
  name: '保定市'
}

/**
 * 常见城市坐标（用于测试和默认值）
 */
export const CITY_COORDINATES = {
  baoding: { latitude: 38.8721, longitude: 115.4925, name: '保定市' },
  beijing: { latitude: 39.9042, longitude: 116.4074, name: '北京市' },
  shanghai: { latitude: 31.2304, longitude: 121.4737, name: '上海市' },
  shenzhen: { latitude: 22.5431, longitude: 114.0579, name: '深圳市' },
  guangzhou: { latitude: 23.1291, longitude: 113.2644, name: '广州市' }
}

export default {
  getPlatform,
  getLocation,
  getLocationH5,
  getLocationMpWeixin,
  checkLocationPermission,
  requestLocationPermission,
  validateCoordinates,
  calculateDistance,
  BAODING_COORDINATES,
  CITY_COORDINATES
}
